/*************************************************************************************
 *  pixelUtilities.c                                                 
 *
 *  synopsis: General Pixel specific utility routines
 *
 *  in this file:   makeGlobalArray, makePixelArray
 *  related files:
 *
 *  John Richardson,  LBNL         (510) 486-4156          john.richardson@cern.ch
 ************************************************************************************/
#if !defined(PIXEL_ROD)


void stub0() {  //define a mini function so that file can always be included in
}               //the project.

#else

#ifndef I_AM_NT_HOST
#include <std.h>
#endif /* I_AM_HOST */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "pixelCommands.h"
#include "pixelConfigStructures.h"


/************************** static function prototypes ************************/

static int LoadPresetSettings(PixelModule *Module, int which_type, int the_chip, int the_choice);
static int ReadMaskFile(PixelModule *Module, int chipnum, char filename[], int masktype);
static int ReadTdacFile(PixelModule *Module, int chipnum, char filename[], int whichtype);
static void terminateString(char *string);

/* removes new line character from input string */
static void terminateString(char *string){
	
	int len=strlen(string);
	
	if(len>1) len--;
	if(string[len]==0xA) string[len]=0; 
	
	return;
}

/*=============================================================================
 *                               readConfigModule()
 *=============================================================================*/
INT32 readConfigModule(PixelModule *Module, char* filename, char *moduleDirectory){

	FILE * infile;
	char dummy_string[260];
	char the_filename[260];
	char fullPath[300];
	char* return_buffer;
	float test, dummy_float;
	int status, ichip, the_numchips, ii, tempval, the_length, dummy, the_choice;
	PixelFEConfig *FEConfig;

   //printf("In Read Config Module!!!!!!!!!!!!!!!!!!!!\n");


	infile = fopen(filename,"r");
	if (infile == NULL){printf ("config file error! Given %s\n",filename);return -1;}
   
   
   
   return_buffer = fgets (dummy_string, 260, infile);

   fscanf(infile,"\n");
   return_buffer = fgets (dummy_string, 260, infile);
   fscanf(infile,"%d ",&dummy);

   return_buffer = fgets (dummy_string, 260, infile);
   fscanf(infile,"%d ",&tempval); 
   Module->mccFlavour = tempval;

   return_buffer = fgets (dummy_string, 260, infile);
   fscanf(infile,"%d ",&tempval); 
   if (tempval == 0)
   {
      Module->feFlavour = FE_I1;
   }
   else if (tempval == 1)
   {
      Module->feFlavour = FE_I2;
   }
   //printf ("FE flavour is %d\n", Module->feFlavour);

   for (ichip = 0; ichip < N_PIXEL_FE_CHIPS; ichip++) 
   {
   
   		FEConfig=&Module->FEConfig[ichip];
   		FEConfig->FEIndex=ichip;
   	
   		fscanf(infile,"\n");
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"\n");   
   
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ", &tempval);
	    FEConfig->FECommand.address=tempval;
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval); 
	    Module->maskEnableFEConfig |= (tempval << ichip);
   
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);    
	    Module->maskEnableFEScan |= (tempval << ichip);

	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);    
	    Module->maskEnableFEDacs |= (tempval << ichip);
 
        if (Module->feFlavour == FE_I2)
        {
	       return_buffer = fgets (dummy_string, 260, infile);
	       fscanf(infile,"%d ",&tempval);
	       FEConfig->FEGlobal.gdac = tempval;
        }
        else
        {
           FEConfig->FEGlobal.gdac = 0;
        }
       

	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacIVDD2=tempval;
 
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacID=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacIP2=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacIP=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacITRIMTH=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacIF=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacITRIMIF=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacITH1=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacITH2=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacIL=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
	    FEConfig->FEGlobal.dacIL2=tempval; 
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);
    
	    FEConfig->FEGlobal.enableCP0 = ((tempval & 0x001)>>0);
	    FEConfig->FEGlobal.enableCP1 = ((tempval & 0x002)>>1);
	    FEConfig->FEGlobal.enableCP2 = ((tempval & 0x004)>>2);
	    FEConfig->FEGlobal.enableCP3 = ((tempval & 0x008)>>3);
	    FEConfig->FEGlobal.enableCP4 = ((tempval & 0x010)>>4);
	    FEConfig->FEGlobal.enableCP5 = ((tempval & 0x020)>>5);
	    FEConfig->FEGlobal.enableCP6 = ((tempval & 0x040)>>6);
	    FEConfig->FEGlobal.enableCP7 = ((tempval & 0x080)>>7);
	    FEConfig->FEGlobal.enableCP8 = ((tempval & 0x100)>>8);
	
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval); 
	    FEConfig->FEGlobal.enableTimestamp=tempval;
     
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&tempval);        
	    FEConfig->FEGlobal.enableCapTest=tempval;
     
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&the_choice);   /* r/o mask choice */
		if (the_choice != FE_MASK_ALTERNATIVE)
		{
	       status = LoadPresetSettings(Module, FE_MASK_ENABLE, ichip, the_choice);
	       if(status!=0) return(-1); 
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    return_buffer = fgets (the_filename, 260, infile);  /* r/o mask */
		// Convert the_filename to full pathname here
		if (the_choice == FE_MASK_ALTERNATIVE)
	    {  
	       sprintf(fullPath, "%s%s", moduleDirectory, the_filename); 
	       terminateString(fullPath);
	       status = ReadMaskFile(Module, ichip, fullPath, FE_MASK_ENABLE);
	       if(status!=0) return(-1);
		}
	
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&the_choice); /* strobe choice */  
		if (the_choice != FE_MASK_ALTERNATIVE)
		{
	       status = LoadPresetSettings(Module, FE_MASK_SELECT, ichip, the_choice);
	       if(status!=0) return(-1);
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    return_buffer = fgets (the_filename, 260, infile);  /* str mask */
		// Convert the_filename to full pathname here
		if (the_choice == FE_MASK_ALTERNATIVE)
	    {  
	       sprintf(fullPath, "%s%s", moduleDirectory, the_filename); 
	       terminateString(fullPath);
	       status = ReadMaskFile(Module, ichip, fullPath, FE_MASK_SELECT);
	       if(status!=0) return(-1);
		}
	
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&the_choice); /* preamp mask choice */  
		if (the_choice != FE_MASK_ALTERNATIVE)
		{
	       status = LoadPresetSettings(Module, FE_MASK_PREAMP, ichip, the_choice);
	       if(status!=0) return(-1);
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    return_buffer = fgets (the_filename, 260, infile);  /* preamp mask */
		// Convert the_filename to full pathname here
		if (the_choice == FE_MASK_ALTERNATIVE)
	    {   
	       sprintf(fullPath, "%s%s", moduleDirectory, the_filename);
	       terminateString(fullPath);
	       status = ReadMaskFile(Module, ichip, fullPath, FE_MASK_PREAMP);
	       if(status!=0) return(-1);
		}
	
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&the_choice); /* hitbus choice */  
		if (the_choice != FE_MASK_ALTERNATIVE)
		{
	       status = LoadPresetSettings(Module, FE_MASK_HITBUS, ichip, the_choice);
	       if(status!=0) return(-1);
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    return_buffer = fgets (the_filename, 260, infile);  /* hitbus mask */
		// Convert the_filename to full pathname here
		if (the_choice == FE_MASK_ALTERNATIVE)
	    {  
	       sprintf(fullPath, "%s%s", moduleDirectory, the_filename);  
	       terminateString(fullPath);
	       status = ReadMaskFile(Module, ichip, fullPath, FE_MASK_HITBUS);
	       if(status!=0) return(-1);
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&the_choice); /* tdac choice */                                        
		if (the_choice != FE_TDACS_ALTERNATIVE)
		{
	       status = LoadPresetSettings(Module, FE_MASK_ACTUALLY_TDACS, ichip, the_choice);
	       if(status!=0) return(-1);
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    return_buffer = fgets (the_filename, 260, infile);  /* tdac file */
		// Convert the_filename to full pathname here
		if (the_choice == FE_TDACS_ALTERNATIVE)
	    {  
	       sprintf(fullPath, "%s%s", moduleDirectory, the_filename);  
	       terminateString(fullPath);
	       status = ReadTdacFile(Module, ichip, fullPath, FE_MASK_ACTUALLY_TDACS);
	       if(status!=0) {printf ("TDAC file error! chip %d fullpath %s\n", ichip, fullPath); return(-1);}
	    }
	
	    return_buffer = fgets (dummy_string, 260, infile);
	    fscanf(infile,"%d ",&the_choice); /* fdac choice */                                        
		if (the_choice != FE_TDACS_ALTERNATIVE)
		{
	       status = LoadPresetSettings(Module, FE_MASK_ACTUALLY_FDACS, ichip, the_choice);
	       if(status!=0) return(-1);
	    }
    
	    return_buffer = fgets (dummy_string, 260, infile);
	    return_buffer = fgets (the_filename, 260, infile);  /* fdac file */
		// Convert the_filename to full pathname here
		if (the_choice == FE_TDACS_ALTERNATIVE)
	    {   
	       sprintf(fullPath, "%s%s", moduleDirectory, the_filename);
	       terminateString(fullPath);
	       status = ReadTdacFile(Module, ichip, fullPath, FE_MASK_ACTUALLY_FDACS);
	       if(status!=0) {printf ("FDAC file error! chip %d fullpath %s\n", ichip, fullPath); return(-1);}
	    }
    
   }
   fscanf(infile,"\n");
   return_buffer = fgets (dummy_string, 260, infile);
   fscanf(infile,"\n");   

   for (ichip = 0; ichip < N_PIXEL_FE_CHIPS; ichip++) 
   {
    	return_buffer = fgets (dummy_string, 260, infile);
    	fscanf(infile,"%f ",&Module->FEConfig[ichip].FECalib.cinjLo);
   }
   
   for (ichip = 0; ichip < N_PIXEL_FE_CHIPS; ichip++) 
   {
    	return_buffer = fgets (dummy_string, 260, infile);
    	fscanf(infile,"%f ",&Module->FEConfig[ichip].FECalib.cinjHi);
   }
   
   for (ichip = 0; ichip < N_PIXEL_FE_CHIPS; ichip++) 
   {
    	return_buffer = fgets (dummy_string, 260, infile);
    	fscanf(infile,"%f ",&Module->FEConfig[ichip].FECalib.vcalGradient);
   }
   
   for (ichip = 0; ichip < N_PIXEL_FE_CHIPS; ichip++) 
   {
    	return_buffer = fgets (dummy_string, 260, infile);
    	fscanf(infile,"%f ",&dummy_float); /* cal offset */
   }
   
   fscanf(infile,"\n");
   return_buffer = fgets (dummy_string, 260, infile);   
   fscanf(infile,"%d ",&dummy); /* was pll phase */
/*   
   fscanf(infile,"\n");
   return_buffer = fgets (dummy_string, 260, infile);   
   fscanf(infile,"%f ",&test);  
   
   if (test > 0.001)
   {
      // module_general.strobe_delay_cal[0] = test; 
	  for (ii=1; ii<16; ii++)
	  {
         return_buffer = fgets (dummy_string, 260, infile);   
         fscanf(infile,"%f ",&dummy_float); // MCC strobe delay cal   
      }
      fscanf(infile,"\n");
      return_buffer = fgets (dummy_string, 260, infile);   
      return_buffer = fgets (dummy_string, 260, infile);   
      the_length = strlen(dummy_string);
      //memcpy(modgenadd->module_id, dummy_string, the_length-1);
	  //module_general.module_id[the_length-1] = '\0';
	  /*
      if (version > 4.6)
      {
         fscanf(infile,"\n");
         fscanf(infile,"\n");
         return_buffer = fgets (dummy_string, 260, infile);   
         fscanf(infile,"%lf",&module_general.mean_t0);
      
         fscanf(infile,"\n");
         return_buffer = fgets (dummy_string, 260, infile);   
         fscanf(infile,"%d",&module_general.mcc_delay_range_t0);

         fscanf(infile,"\n");
         return_buffer = fgets (dummy_string, 260, infile);   
         fscanf(infile,"%d",&module_general.trigger_delay_t0);
      }      
      */
   //}
   
   fclose(infile);

return 0;
}

static int ReadMaskFile(PixelModule *Module, int chipnum, char filename[], int masktype)
{
int ii;
int dummy;
FILE * infile;
int status;

   infile = fopen(filename,"r");
   if (infile == NULL){return -1;}
      for (ii = 0; ii < 18; ii++)
      {
         switch (masktype)
         {
         case FE_MASK_ENABLE:
            fscanf(infile,"%x %x %x %x %x %x ", &dummy,
                   &Module->FEConfig[chipnum].FEMasks.maskEnable[0][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskEnable[1][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskEnable[2][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskEnable[3][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskEnable[4][ii]);
   		 break;
   		 case FE_MASK_SELECT:
            fscanf(infile,"%x %x %x %x %x %x ", &dummy,
                   &Module->FEConfig[chipnum].FEMasks.maskSelect[0][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskSelect[1][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskSelect[2][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskSelect[3][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskSelect[4][ii]);
   		 break;
         case FE_MASK_PREAMP:
            fscanf(infile,"%x %x %x %x %x %x ", &dummy,
                   &Module->FEConfig[chipnum].FEMasks.maskPreamp[0][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskPreamp[1][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskPreamp[2][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskPreamp[3][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskPreamp[4][ii]);
   		 break;
   		 case FE_MASK_HITBUS:
            fscanf(infile,"%x %x %x %x %x %x ", &dummy,
                   &Module->FEConfig[chipnum].FEMasks.maskHitbus[0][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskHitbus[1][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskHitbus[2][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskHitbus[3][ii],
                   &Module->FEConfig[chipnum].FEMasks.maskHitbus[4][ii]);
   		 break;   		 
   		 default:
   		 return -1;
   		 } 
   	  }
   	  status = fclose(infile);
   	  
return 0;   
}   

static int ReadTdacFile(PixelModule *Module, int chipnum, char filename[], int whichtype)                       
{                                                                                 
int ii;                                                                           
int jj;                                                                           
FILE * infile;
int status;
int value;
                                                                                  
   infile = fopen(filename,"r");                                              
            
   if (infile == NULL){return -1;}
                                                                                  
      for (jj = 0; jj < 160; jj++)                                                 
      {             
         for (ii = 0; ii < 18; ii++)
         {
			if (whichtype == FE_MASK_ACTUALLY_TDACS)
			{
               fscanf(infile,"%d ", &value);
               Module->FEConfig[chipnum].FETrims.dacThresholdTrim[jj][ii]=value;
		    }
		    else if (whichtype == FE_MASK_ACTUALLY_FDACS) 
		    {
               fscanf(infile,"%d ", &value);
               Module->FEConfig[chipnum].FETrims.dacFeedbackTrim[jj][ii]=value;
		    }
		 }
		 fscanf(infile,"\n");
	  }
	  status = fclose(infile);
   	                                                                              
return 0;                                                                         
}   

static int LoadPresetSettings(PixelModule *Module, int which_type, int the_chip, int the_choice)
{
int zcol;
int zrow;
int jj;

        switch (which_type)
        {
        case FE_MASK_ENABLE:
		   switch (the_choice)
		   {
		   case FE_MASK_ALTERNATIVE:
		   break;
           case FE_MASK_ALL_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
         		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }
		   break;
		   case FE_MASK_ALL_OFF:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }
		   break;
           case FE_MASK_ODDS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xAAAAAAAA;
                  }
               }
		   break;           
		   case FE_MASK_EVENS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x55555555;
                  }
               }
		   break;

		    case FE_MASK_0_9:
               for (zcol = 0; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		                 
		    break;

		    case FE_MASK_0_1:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 0; zcol < 2; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_2_3:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 2; zcol < 4; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_4_5:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 4; zcol < 6; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_6_7:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 6; zcol < 8; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_8_9:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 8; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_10_11:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 10; zcol < 12; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_12_13:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 12; zcol < 13; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_14_15:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 14; zcol < 16; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_16_17:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 16; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;	

		    case FE_MASK_ALL_NO_GANG:
               for (zcol = 0; zcol < 18; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskEnable[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
		    break;	
		    
		    case FE_MASK_0_9_NO_GANG:
               for (zcol = 0; zcol < 10; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskEnable[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskEnable[jj][zcol] = 0x00000000;
                  }
               }	     
		    break;
		    
        }
        break;
        case FE_MASK_SELECT:
		   switch (the_choice)
		   {
		   case FE_MASK_ALTERNATIVE:
		   break;
           case FE_MASK_ALL_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }
		   break;
		   case FE_MASK_ALL_OFF:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }
		   break;
		   case FE_MASK_ODDS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xAAAAAAAA;
                  }
               }
		   break;           
		   case FE_MASK_EVENS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x55555555;
                  }
               }
		   break;           
		    case FE_MASK_0_9:
               for (zcol = 0; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		                 
		    break;
		    case FE_MASK_0_1:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 0; zcol < 2; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_2_3:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 2; zcol < 4; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_4_5:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 4; zcol < 6; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_6_7:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 6; zcol < 8; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_8_9:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 8; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_10_11:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 10; zcol < 12; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_12_13:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 12; zcol < 13; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_14_15:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 14; zcol < 16; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_16_17:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 16; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;	
		    case FE_MASK_ALL_NO_GANG:
               for (zcol = 0; zcol < 18; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskSelect[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
		    break;			  
		    case FE_MASK_0_9_NO_GANG:
               for (zcol = 0; zcol < 10; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskSelect[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskSelect[jj][zcol] = 0x00000000;
                  }
               }	     
		    break;					    
		   
           }
        break;
        case FE_MASK_PREAMP:
		   switch (the_choice)
		   {
		   case FE_MASK_ALTERNATIVE:
		   break;
           case FE_MASK_ALL_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }
		   break;
		   case FE_MASK_ALL_OFF:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }
		   break;
		   case FE_MASK_ODDS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xAAAAAAAA;
                  }
               }
		   break;           
		   case FE_MASK_EVENS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x55555555;
                  }
               }
		   break;           
		    case FE_MASK_0_9:
               for (zcol = 0; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		                 
		    break;
		    case FE_MASK_0_1:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 0; zcol < 2; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_2_3:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 2; zcol < 4; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_4_5:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 4; zcol < 6; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_6_7:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 6; zcol < 8; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_8_9:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 8; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_10_11:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 10; zcol < 12; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_12_13:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 12; zcol < 13; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_14_15:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 14; zcol < 16; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_16_17:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 16; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;	
		    case FE_MASK_ALL_NO_GANG:
               for (zcol = 0; zcol < 18; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskPreamp[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
		    break;			  
		    case FE_MASK_0_9_NO_GANG:
               for (zcol = 0; zcol < 10; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskPreamp[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskPreamp[jj][zcol] = 0x00000000;
                  }
               }	     
		    break;					    
		   
           }
        break;        
        case FE_MASK_HITBUS:
		   switch (the_choice)
		   {
		   case FE_MASK_ALTERNATIVE:
		   break;
           case FE_MASK_ALL_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }
		   break;
		   case FE_MASK_ALL_OFF:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }
		   break;
		   case FE_MASK_ODDS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xAAAAAAAA;
                  }
               }
		   break;           
		   case FE_MASK_EVENS_ON:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x55555555;
                  }
               }
		   break;           
		    case FE_MASK_0_9:
               for (zcol = 0; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		                 
		    break;
		    case FE_MASK_0_1:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 0; zcol < 2; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_2_3:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 2; zcol < 4; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_4_5:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 4; zcol < 6; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_6_7:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 6; zcol < 8; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_8_9:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 8; zcol < 10; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_10_11:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 10; zcol < 12; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_12_13:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 12; zcol < 13; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_14_15:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 14; zcol < 16; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;		    
		    case FE_MASK_16_17:
               for (zcol = 0; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }		    
               for (zcol = 16; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		                 
		    break;	
		    case FE_MASK_ALL_NO_GANG:
               for (zcol = 0; zcol < 18; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskHitbus[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
		    break;			  
		    case FE_MASK_0_9_NO_GANG:
               for (zcol = 0; zcol < 10; zcol++)
               {
        		  Module->FEConfig[the_chip].FEMasks.maskHitbus[0][zcol] = 0x55FFFFFF;
                  for (jj=1; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0xFFFFFFFF;
                  }
               }		    
               for (zcol = 10; zcol < 18; zcol++)
               {
                  for (jj=0; jj<5; jj++)
                  {
        		     Module->FEConfig[the_chip].FEMasks.maskHitbus[jj][zcol] = 0x00000000;
                  }
               }	     
		    break;					    
		   
           }
        break;                
        case FE_MASK_ACTUALLY_TDACS:
		   if (the_choice != FE_TDACS_ALTERNATIVE)
		   {
              for (zrow = 0; zrow < 160; zrow++)                                                 
              {             
                 for (zcol = 0; zcol < 18; zcol++)
                 {
                    Module->FEConfig[the_chip].FETrims.dacThresholdTrim[zrow][zcol] = the_choice;
		         } 
	          }           
		   }
        break;
        case FE_MASK_ACTUALLY_FDACS:
		   if (the_choice != FE_TDACS_ALTERNATIVE)
		   {
              for (zrow = 0; zrow < 160; zrow++)                                                 
              {             
                 for (zcol = 0; zcol < 18; zcol++)
                 {
                    Module->FEConfig[the_chip].FETrims.dacFeedbackTrim[zrow][zcol] = the_choice;
		         } 
	          }           
		   }
        break;        
        }
	return 0;
}

/*=============================================================================
 *                               writeConfigModule()
 *=============================================================================*/
INT32 writeConfigModule(PixelModule *Module, char* filename){

	FILE* file;
	int chipIndex, i, j;
  
  	PixelFEConfig *FEConfig;

	file = fopen(filename,"w");
  	if (file == NULL){
    	return (-1);
  	}
	//----------------------------
    fprintf(file,"struct PixelModule:\n===================\n");
    
	fprintf(file, "maskEnableFEConfig: 0x%x\n", Module->maskEnableFEConfig);
	fprintf(file, "maskEnableFEScan  : 0x%x\n", Module->maskEnableFEScan);
	fprintf(file, "maskEnableFEDacs  : 0x%x\n\n", Module->maskEnableFEDacs);
	
	fprintf(file, "present: %d\n", Module->present); 
	fprintf(file, "active : %d\n", Module->active);
	fprintf(file, "groupId: %d\n", Module->groupId);

	/* MCC configuration */	
	fprintf(file,"\nMCCRegisters:\n-------------------\n");
	
	fprintf(file, "regCSR : 0x%x\n", Module->MCCRegisters.regCSR); 
	fprintf(file, "regLV1 : 0x%x\n", Module->MCCRegisters.regLV1);
	fprintf(file, "regFEEN: 0x%x\n", Module->MCCRegisters.regFEEN);
	fprintf(file, "regWFE : 0x%x\n", Module->MCCRegisters.regWFE);
	fprintf(file, "regWMCC: 0x%x\n", Module->MCCRegisters.regWMCC);
	fprintf(file, "regCNT : 0x%x\n", Module->MCCRegisters.regCNT);
	fprintf(file, "regCAL : 0x%x\n", Module->MCCRegisters.regCAL);
	fprintf(file, "regPEF : 0x%x\n", Module->MCCRegisters.regPEF);
	  	
	
    /* FE configurations: */      
    for(chipIndex=0; chipIndex<N_PIXEL_FE_CHIPS; ++chipIndex){
    
    	fprintf(file,"\nFEConfig[%d]:\n-------------------\n", chipIndex);
    	
    	FEConfig=&Module->FEConfig[chipIndex];
    	fprintf(file, "FEConfig.FEIndex: %d\n\n", FEConfig->FEIndex);
    	
		fprintf(file, "FECommand.address: %d\n", FEConfig->FECommand.address); 
		fprintf(file, "FECommand.command: 0x%x\n", FEConfig->FECommand.command);

		fprintf(file, "\nFEGlobal.latency            : %d\n", FEConfig->FEGlobal.latency          );
		fprintf(file, "FEGlobal.dacIVDD2           : %d\n", FEConfig->FEGlobal.dacIVDD2           );
		fprintf(file, "FEGlobal.dacIP2             : %d\n", FEConfig->FEGlobal.dacIP2             );
		fprintf(file, "FEGlobal.dacID              : %d\n", FEConfig->FEGlobal.dacID              );
		fprintf(file, "FEGlobal.dacIP              : %d\n", FEConfig->FEGlobal.dacIP              );
		fprintf(file, "FEGlobal.dacITRIMTH         : %d\n", FEConfig->FEGlobal.dacITRIMTH         );
		fprintf(file, "FEGlobal.dacIF              : %d\n", FEConfig->FEGlobal.dacIF              );
		fprintf(file, "FEGlobal.dacITH1            : %d\n", FEConfig->FEGlobal.dacITH1            );
		fprintf(file, "FEGlobal.dacITH2            : %d\n", FEConfig->FEGlobal.dacITH2            );
		fprintf(file, "FEGlobal.dacIL              : %d\n", FEConfig->FEGlobal.dacIL              );
		fprintf(file, "FEGlobal.dacIL2             : %d\n", FEConfig->FEGlobal.dacIL2             );
		fprintf(file, "FEGlobal.dacITRIMIF         : %d\n", FEConfig->FEGlobal.dacITRIMIF         );
		fprintf(file, "FEGlobal.dacSpare           : %d\n", FEConfig->FEGlobal.dacSpare           );
		fprintf(file, "FEGlobal.threshTOTMinimum   : %d\n", FEConfig->FEGlobal.threshTOTMinimum   );
		fprintf(file, "FEGlobal.threshTOTDouble    : %d\n", FEConfig->FEGlobal.threshTOTDouble    );
		fprintf(file, "FEGlobal.capMeasure         : %d\n", FEConfig->FEGlobal.capMeasure         );
		fprintf(file, "FEGlobal.muxTestPixel       : %d\n", FEConfig->FEGlobal.muxTestPixel       );
		fprintf(file, "FEGlobal.dacMonLeakADC      : %d\n", FEConfig->FEGlobal.dacMonLeakADC      );
		fprintf(file, "FEGlobal.dacVCAL            : %d\n", FEConfig->FEGlobal.dacVCAL            );
		fprintf(file, "FEGlobal.widthSelfTrigger   : %d\n", FEConfig->FEGlobal.widthSelfTrigger   );
		fprintf(file, "FEGlobal.muxDO              : %d\n", FEConfig->FEGlobal.muxDO              );
		fprintf(file, "FEGlobal.muxMonHit          : %d\n", FEConfig->FEGlobal.muxMonHit          );
		fprintf(file, "FEGlobal.muxEOC             : %d\n", FEConfig->FEGlobal.muxEOC             );
		fprintf(file, "FEGlobal.frequencyCEU       : %d\n", FEConfig->FEGlobal.frequencyCEU       );
		fprintf(file, "FEGlobal.modeTOTThresh      : %d\n", FEConfig->FEGlobal.modeTOTThresh      );
		fprintf(file, "FEGlobal.enableTimestamp    : %d\n", FEConfig->FEGlobal.enableTimestamp    );
		fprintf(file, "FEGlobal.enableSelfTrigger  : %d\n", FEConfig->FEGlobal.enableSelfTrigger  );
		fprintf(file, "FEGlobal.spare              : %d\n", FEConfig->FEGlobal.spare              );
		fprintf(file, "FEGlobal.monMonLeakADC      : %d\n", FEConfig->FEGlobal.monMonLeakADC      );
		fprintf(file, "FEGlobal.monADCRef          : %d\n", FEConfig->FEGlobal.monADCRef          );
		fprintf(file, "FEGlobal.enableMonLeak      : %d\n", FEConfig->FEGlobal.enableMonLeak      );
		fprintf(file, "FEGlobal.statusMonLeak      : %d\n", FEConfig->FEGlobal.statusMonLeak      );
		fprintf(file, "FEGlobal.enableCapTest      : %d\n", FEConfig->FEGlobal.enableCapTest      );
		fprintf(file, "FEGlobal.enableBuffer       : %d\n", FEConfig->FEGlobal.enableBuffer       );
		fprintf(file, "FEGlobal.enableVcalMeasure  : %d\n", FEConfig->FEGlobal.enableVcalMeasure  );
		fprintf(file, "FEGlobal.enableLeakMeasure  : %d\n", FEConfig->FEGlobal.enableLeakMeasure  );
		fprintf(file, "FEGlobal.enableBufferBoost  : %d\n", FEConfig->FEGlobal.enableBufferBoost  );
		fprintf(file, "FEGlobal.enableCP8          : %d\n", FEConfig->FEGlobal.enableCP8          );
		fprintf(file, "FEGlobal.monIVDD2           : %d\n", FEConfig->FEGlobal.monIVDD2           );
		fprintf(file, "FEGlobal.monID              : %d\n", FEConfig->FEGlobal.monID              );
		fprintf(file, "FEGlobal.enableCP7          : %d\n", FEConfig->FEGlobal.enableCP7          );
		fprintf(file, "FEGlobal.monIP2             : %d\n", FEConfig->FEGlobal.monIP2             );
		fprintf(file, "FEGlobal.monIP              : %d\n", FEConfig->FEGlobal.monIP              );
		fprintf(file, "FEGlobal.enableCP6          : %d\n", FEConfig->FEGlobal.enableCP6          );
		fprintf(file, "FEGlobal.monITRIMTH         : %d\n", FEConfig->FEGlobal.monITRIMTH         );
		fprintf(file, "FEGlobal.monIF              : %d\n", FEConfig->FEGlobal.monIF              );
		fprintf(file, "FEGlobal.enableCP5          : %d\n", FEConfig->FEGlobal.enableCP5          );
		fprintf(file, "FEGlobal.monITRIMIF         : %d\n", FEConfig->FEGlobal.monITRIMIF         );
		fprintf(file, "FEGlobal.monVCAL            : %d\n", FEConfig->FEGlobal.monVCAL            );
		fprintf(file, "FEGlobal.enableCP4          : %d\n", FEConfig->FEGlobal.enableCP4          );
		fprintf(file, "FEGlobal.enableCinjHigh     : %d\n", FEConfig->FEGlobal.enableCinjHigh     );
		fprintf(file, "FEGlobal.enableExternal     : %d\n", FEConfig->FEGlobal.enableExternal     );
		fprintf(file, "FEGlobal.enableTestAnalogRef: %d\n", FEConfig->FEGlobal.enableTestAnalogRef);
		fprintf(file, "FEGlobal.enableDigital      : %d\n", FEConfig->FEGlobal.enableDigital      );
		fprintf(file, "FEGlobal.enableCP3          : %d\n", FEConfig->FEGlobal.enableCP3          );
		fprintf(file, "FEGlobal.monITH1            : %d\n", FEConfig->FEGlobal.monITH1            );
		fprintf(file, "FEGlobal.monITH2            : %d\n", FEConfig->FEGlobal.monITH2            );
		fprintf(file, "FEGlobal.enableCP2          : %d\n", FEConfig->FEGlobal.enableCP2          );
		fprintf(file, "FEGlobal.monIL              : %d\n", FEConfig->FEGlobal.monIL              );
		fprintf(file, "FEGlobal.monIL2             : %d\n", FEConfig->FEGlobal.monIL2             );
		fprintf(file, "FEGlobal.enableCP1          : %d\n", FEConfig->FEGlobal.enableCP1          );
		fprintf(file, "FEGlobal.enableCP0          : %d\n", FEConfig->FEGlobal.enableCP0          );
		fprintf(file, "FEGlobal.monSpare           : %d\n", FEConfig->FEGlobal.monSpare           );
		
		fprintf(file, "\n[%d]FEMasks.maskEnable:\n", chipIndex);
		for(i=0; i<N_PIXEL_COLUMNS; ++i){
			fprintf(file, "%2d: ", i);
			for(j=0; j<5; ++j){
				fprintf(file, "%8x ", FEConfig->FEMasks.maskEnable[j][i]);		
			}
			fprintf(file, "\n");  
		}
		
		fprintf(file, "\n[%d]FEMasks.maskSelect:\n", chipIndex);
		for(i=0; i<N_PIXEL_COLUMNS; ++i){
			fprintf(file, "%2d: ", i);
			for(j=0; j<5; ++j){
				fprintf(file, "%8x ", FEConfig->FEMasks.maskSelect[j][i]);		
			}
			fprintf(file, "\n");  
		}
		
		fprintf(file, "\n[%d]FEMasks.maskPreamp:\n", chipIndex); 
		for(i=0; i<N_PIXEL_COLUMNS; ++i){
			fprintf(file, "%2d: ", i);
			for(j=0; j<5; ++j){
				fprintf(file, "%8x ", FEConfig->FEMasks.maskPreamp[j][i]);		
			}
			fprintf(file, "\n");  
		}
		
		fprintf(file, "\n[%d]FEMasks.maskHitbus:\n", chipIndex); 
		for(i=0; i<N_PIXEL_COLUMNS; ++i){
			fprintf(file, "%2d: ", i);
			for(j=0; j<5; ++j){
				fprintf(file, "%8x ", FEConfig->FEMasks.maskHitbus[j][i]);		
			}
			fprintf(file, "\n");  
		}	

		fprintf(file, "\n[%d]FEMasks.dacThresholdTrim:\n", chipIndex); 
		for(i=0; i<N_PIXEL_ROWS; ++i){
			fprintf(file, "%3d: ", i);
			for(j=0; j<N_PIXEL_COLUMNS; ++j){
				fprintf(file, "%2d ", FEConfig->FETrims.dacThresholdTrim[i][j]);		
			}
			fprintf(file, "\n");  
		}	
		
		fprintf(file, "\n[%d]FEMasks.dacFeedbackTrim:\n", chipIndex); 
		for(i=0; i<N_PIXEL_ROWS; ++i){
			fprintf(file, "%3d: ", i);
			for(j=0; j<N_PIXEL_COLUMNS; ++j){
				fprintf(file, "%2d ", FEConfig->FETrims.dacFeedbackTrim[i][j]);		
			}
			fprintf(file, "\n");  
		}	
		
		fprintf(file, "\n[%d]:\n", chipIndex);
		fprintf(file, "FECalib.cinjLo;        : %f\n", FEConfig->FECalib.cinjLo       );
		fprintf(file, "FECalib.cinjHi;        : %f\n", FEConfig->FECalib.cinjHi         ); 
		fprintf(file, "FECalib.vcalGradient;  : %f\n", FEConfig->FECalib.vcalGradient   ); 
		fprintf(file, "FECalib.chargeCoeffClo;: %f\n", FEConfig->FECalib.chargeCoeffClo ); 
		fprintf(file, "FECalib.chargeCoeffChi;: %f\n", FEConfig->FECalib.chargeCoeffChi ); 
		fprintf(file, "FECalib.chargeOffsetClo: %f\n", FEConfig->FECalib.chargeOffsetClo); 
		fprintf(file, "FECalib.chargeOffsetChi: %f\n", FEConfig->FECalib.chargeOffsetChi); 
		fprintf(file, "FECalib.monleakCoeff;  : %f\n", FEConfig->FECalib.monleakCoeff   ); 
	}	

  //-------------------------------
  fclose(file);

  return 0;
}

#endif   /* Pixel function block. */