void OrientedGrowthPlugin::update(CC3DXMLElement *_xmlData, bool _fullInitFlag){
    //PARSE XML IN THIS FUNCTION
    //For more information on XML parser function please see CC3D code or lookup XML utils API
    automaton = potts->getAutomaton();
    ASSERT_OR_THROW("CELL TYPE PLUGIN WAS NOT PROPERLY INITIALIZED YET. MAKE SURE THIS IS THE FIRST PLUGIN THAT YOU SET", automaton)
   set<unsigned char> cellTypesSet;

    CC3DXMLElement * myElementOne = xmlData->getFirstElement("Penalty");
    if(myElementOne){
        xml_energy_penalty = myElementOne->getDouble();
    }else{
        xml_energy_penalty = 99999;
    }
    
    CC3DXMLElement * myElementTwo = xmlData->getFirstElement("Falloff");
    if(myElementTwo){
        xml_energy_falloff = myElementTwo->getDouble();
    }else{
        xml_energy_falloff = 1;
    }
    
    //boundaryStrategy has information aobut pixel neighbors 
    boundaryStrategy=BoundaryStrategy::getInstance();
}
void ConnectivityGlobalPlugin::update(CC3DXMLElement *_xmlData, bool _fullInitFlag) {

	if (potts->getDisplayUnitsFlag()) {
		Unit energyUnit = potts->getEnergyUnit();




		CC3DXMLElement * unitsElem = _xmlData->getFirstElement("Units");
		if (!unitsElem) { //add Units element
			unitsElem = _xmlData->attachElement("Units");
		}

		if (unitsElem->getFirstElement("PenaltyUnit")) {
			unitsElem->getFirstElement("PenaltyUnit")->updateElementValue(energyUnit.toString());
		}
		else {
			CC3DXMLElement * energyElem = unitsElem->attachElement("PenaltyUnit", energyUnit.toString());
		}
	}

	penaltyVec.clear();

	Automaton *automaton = potts->getAutomaton();
	ASSERT_OR_THROW("CELL TYPE PLUGIN WAS NOT PROPERLY INITIALIZED YET. MAKE SURE THIS IS THE FIRST PLUGIN THAT YOU SET", automaton)
		set<unsigned char> cellTypesSet;


	map<unsigned char, double> typeIdConnectivityPenaltyMap;

	if (_xmlData->getFirstElement("DoNotPrecheckConnectivity")) {
		doNotPrecheckConnectivity = true;
	}

	if (_xmlData->getFirstElement("FastAlgorithm")) {
		fast_algorithm = true;
		changeEnergyFcnPtr = &ConnectivityGlobalPlugin::changeEnergyFast;
	}


	CC3DXMLElementList penaltyVecXML = _xmlData->getElements("Penalty");

	CC3DXMLElementList connectivityOnVecXML = _xmlData->getElements("ConnectivityOn");

	ASSERT_OR_THROW("You cannot use Penalty and ConnectivityOn tags together. Stick to one convention", !(connectivityOnVecXML.size() && penaltyVecXML.size()));

	// previous ASSERT_OR_THROW will encure that only one of the subsequent for loops be executed 

	for (int i = 0; i < penaltyVecXML.size(); ++i) {
		typeIdConnectivityPenaltyMap.insert(make_pair(automaton->getTypeId(penaltyVecXML[i]->getAttribute("Type")), penaltyVecXML[i]->getDouble()));


		//inserting all the types to the set (duplicate are automatically eleminated) to figure out max value of type Id
		cellTypesSet.insert(automaton->getTypeId(penaltyVecXML[i]->getAttribute("Type")));

	}



	for (int i = 0; i < connectivityOnVecXML.size(); ++i) {
		typeIdConnectivityPenaltyMap.insert(make_pair(automaton->getTypeId(connectivityOnVecXML[i]->getAttribute("Type")), 1.0));
		//inserting all the types to the set (duplicate are automatically eleminated) to figure out max value of type Id
		cellTypesSet.insert(automaton->getTypeId(connectivityOnVecXML[i]->getAttribute("Type")));

	}


	//Now that we know all the types used in the simulation we will find size of the penaltyVec
	vector<unsigned char> cellTypesVector(cellTypesSet.begin(), cellTypesSet.end());//coping set to the vector

	int size = 0;
	if (cellTypesVector.size()) {
		size = *max_element(cellTypesVector.begin(), cellTypesVector.end());
	}

	maxTypeId = size;

	size += 1;//if max element is e.g. 5 then size has to be 6 for an array to be properly allocated



	int index;
	penaltyVec.assign(size, 0.0);
	//inserting connectivity penalty values to penaltyVec;
	for (map<unsigned char, double>::iterator mitr = typeIdConnectivityPenaltyMap.begin(); mitr != typeIdConnectivityPenaltyMap.end(); ++mitr) {
		penaltyVec[mitr->first] = fabs(mitr->second);
	}

	cerr << "size=" << size << endl;
	for (int i = 0; i < size; ++i) {
		cerr << "penaltyVec[" << i << "]=" << penaltyVec[i] << endl;
	}

	//Here I initialize max neighbor index for direct acces to the list of neighbors 
	boundaryStrategy = BoundaryStrategy::getInstance();
	maxNeighborIndex = 0;


	maxNeighborIndex = boundaryStrategy->getMaxNeighborIndexFromNeighborOrder(1);


	cerr << "ConnectivityGlobal maxNeighborIndex=" << maxNeighborIndex << endl;

	
	WatchableField3D<CellG *> *cellFieldG = (WatchableField3D<CellG *> *)potts->getCellFieldG();
	Dim3D fieldDim = cellFieldG->getDim();

	// max_neighbor_index_local_search is different depending whether we are on hex or cartesian lattice and if this is 2D or 3D simulation
	if (boundaryStrategy->getLatticeType() == HEXAGONAL_LATTICE) { // on hex lattice in 2D and 3D nearest neighbors "completely cover" a given pixel 
		max_neighbor_index_local_search = boundaryStrategy->getMaxNeighborIndexFromNeighborOrder(1);
	}
	else {
		if (fieldDim.x == 1 || fieldDim.y == 1 || fieldDim.z == 1) { //2D simulation 
			max_neighbor_index_local_search = boundaryStrategy->getMaxNeighborIndexFromNeighborOrder(2);
		}
		else { //3D
			max_neighbor_index_local_search = boundaryStrategy->getMaxNeighborIndexFromNeighborOrder(3);
		}
	}

}
void AdhesionFlexPlugin::update(CC3DXMLElement *_xmlData, bool _fullInitFlag){

	automaton = potts->getAutomaton();
	ASSERT_OR_THROW("CELL TYPE PLUGIN WAS NOT PROPERLY INITIALIZED YET. MAKE SURE THIS IS THE FIRST PLUGIN THAT YOU SET", automaton)
		set<unsigned char> cellTypesSet;


	//scanning Adhesion Molecule names

	CC3DXMLElementList adhesionMoleculeNameXMLVec=_xmlData->getElements("AdhesionMolecule");
	vector<string> adhesionMoleculeNameVec;
	set<string> adhesionMoleculeNameSet;
	moleculeNameIndexMap.clear();

	for (int i = 0 ; i<adhesionMoleculeNameXMLVec.size(); ++i){
		string moleculeName=adhesionMoleculeNameXMLVec[i]->getAttribute("Molecule");
		if (! adhesionMoleculeNameSet.insert(moleculeName).second){
			ASSERT_OR_THROW(string("Duplicate molecule Name=")+moleculeName+ " specified in AdhesionMolecule section ", false);
		}        
		adhesionMoleculeNameVec.push_back(moleculeName);
		moleculeNameIndexMap.insert(make_pair(moleculeName,i));
	}

	numberOfAdhesionMolecules=moleculeNameIndexMap.size();
	if (!sim->getRestartEnabled()){	
		adhesionMoleculeDensityVecMedium=vector<float>(numberOfAdhesionMolecules,0.0);
	}
	cerr<<"numberOfAdhesionMolecules="<<numberOfAdhesionMolecules<<endl;

	//scannning AdhesionMoleculeDensity section

	CC3DXMLElementList adhesionMoleculeDensityXMLVec=_xmlData->getElements("AdhesionMoleculeDensity");    
	typeToAdhesionMoleculeDensityMap.clear();
	std::map<int,std::vector<float> >::iterator mitr;

	for (int i = 0 ; i<adhesionMoleculeDensityXMLVec.size(); ++i){
		int typeId=automaton->getTypeId(adhesionMoleculeDensityXMLVec[i]->getAttribute("CellType"));

		cerr<<"typeId="<<typeId<<endl;


		mitr=typeToAdhesionMoleculeDensityMap.find(typeId);
		if (mitr==typeToAdhesionMoleculeDensityMap.end()){
			typeToAdhesionMoleculeDensityMap.insert(make_pair(typeId,vector<float>(numberOfAdhesionMolecules,0.0)));
			cerr<<"typeToAdhesionMoleculeDensityMap[typeId].size()="<<typeToAdhesionMoleculeDensityMap[typeId].size()<<endl;
		}


		string moleculeName=adhesionMoleculeDensityXMLVec[i]->getAttribute("Molecule");
		cerr<<"moleculeName="<<moleculeName<<endl;
		if(moleculeNameIndexMap.find(moleculeName)==moleculeNameIndexMap.end()){
			ASSERT_OR_THROW(string("Molecule Name=")+moleculeName+" was not declared in the AdhesionMolecule section",false);
		}
		cerr<<"moleculeNameIndexMap[moleculeName]="<<moleculeNameIndexMap[moleculeName]<<endl;
		cerr<<"adhesionMoleculeDensityXMLVec[i]->getAttributeAsDouble(Density)="<<adhesionMoleculeDensityXMLVec[i]->getAttributeAsDouble("Density")<<endl;
		cerr<<"typeToAdhesionMoleculeDensityMap[typeId].size()="<<typeToAdhesionMoleculeDensityMap[typeId].size()<<endl;
		typeToAdhesionMoleculeDensityMap[typeId][moleculeNameIndexMap[moleculeName]]=adhesionMoleculeDensityXMLVec[i]->getAttributeAsDouble("Density");
		cerr<<"AFTER ASSIGNING DENSITY"<<endl;
	}


	//scanning BindingFormula section

	CC3DXMLElement * bindingFormulaXMLElem=_xmlData->getFirstElement("BindingFormula");

	formulaString=bindingFormulaXMLElem->getFirstElement("Formula")->getText(); //formula string

	CC3DXMLElement * variablesSectionXMLElem=bindingFormulaXMLElem->getFirstElement("Variables");
	//cerr<<"formulaString="<<formulaString<<endl;


	//here we can add options depending on variables input - for now it is har-coded to accept only matrix of bindingParameters
	bindingParameters.clear() ; //have to clear binding parameters
	CC3DXMLElement * adhesionInteractionMatrixXMLElem = variablesSectionXMLElem->getFirstElement("AdhesionInteractionMatrix");
	CC3DXMLElementList bindingParameterXMLVec = adhesionInteractionMatrixXMLElem->getElements("BindingParameter");
	for (int i = 0 ; i<bindingParameterXMLVec.size(); ++i){		
		setBindingParameter(bindingParameterXMLVec[i]->getAttribute("Molecule1") , bindingParameterXMLVec[i]->getAttribute("Molecule2"), bindingParameterXMLVec[i]->getDouble());
	}


    //vectorized variables for convenient parallel access 
   unsigned int maxNumberOfWorkNodes=pUtils->getMaxNumberOfWorkNodesPotts();
   molecule1Vec.assign(maxNumberOfWorkNodes,0.0);
   molecule2Vec.assign(maxNumberOfWorkNodes,0.0);
   pVec.assign(maxNumberOfWorkNodes,mu::Parser());    

   for (int i  = 0 ; i< maxNumberOfWorkNodes ; ++i){
    pVec[i].DefineVar("Molecule1",&molecule1Vec[i]);
    pVec[i].DefineVar("Molecule2",&molecule2Vec[i]);
    pVec[i].SetExpr(formulaString);
   }

	// p=mu::Parser(); //using new parser
	// //setting up muParser
	// p.DefineVar("Molecule1", &molecule1);
	// p.DefineVar("Molecule2", &molecule2);	
	// p.SetExpr(formulaString);





	//scanning NeighborOrder or Depth
	//Here I initialize max neighbor index for direct acces to the list of neighbors 
	boundaryStrategy=BoundaryStrategy::getInstance();
	maxNeighborIndex=0;

	if(_xmlData->getFirstElement("Depth")){
		maxNeighborIndex=boundaryStrategy->getMaxNeighborIndexFromDepth(_xmlData->getFirstElement("Depth")->getDouble());
		//cerr<<"got here will do depth"<<endl;
	}else{
		//cerr<<"got here will do neighbor order"<<endl;
		if(_xmlData->getFirstElement("NeighborOrder")){

			maxNeighborIndex=boundaryStrategy->getMaxNeighborIndexFromNeighborOrder(_xmlData->getFirstElement("NeighborOrder")->getUInt());	
			cerr<<"maxNeighborIndex="<<maxNeighborIndex<<endl;
		}else{
			maxNeighborIndex=boundaryStrategy->getMaxNeighborIndexFromNeighborOrder(1);

		}

	}


	cerr<<"sizeBindingArray="<<moleculeNameIndexMap.size()<<endl;
	//initializing binding parameter array
	int sizeBindingArray=moleculeNameIndexMap.size();

	int indexBindingArray ;
	bindingParameterArray.clear();
	bindingParameterArray.assign(sizeBindingArray,vector<double>(sizeBindingArray,0.0));
	bindingParameters_t::iterator bmitr;
	
	for(int i = 0 ; i < sizeBindingArray ; ++i)
		for(int j = 0 ; j < sizeBindingArray ; ++j){

			indexBindingArray= getIndex(i,j);

			bmitr=bindingParameters.find(indexBindingArray);

			if(bmitr!=bindingParameters.end()){
				bindingParameterArray[i][j] = bmitr->second;
			}


		}

		for(int i = 0 ; i < sizeBindingArray ; ++i)
			for(int j = 0 ; j < sizeBindingArray ; ++j){

				cerr<<"bindingParameterArray["<<i<<"]["<<j<<"]="<<bindingParameterArray[i][j]<<endl;

			}    

			


}
Beispiel #4
0
void FiPySolver::update(CC3DXMLElement *_xmlData, bool _fullInitFlag){
	
	//notice, only basic steering is enabled for PDE solvers - changing diffusion constants, do -not-diffuse to types etc...
	// Coupling coefficients cannot be changed and also there is no way to allocate extra fields while simulation is running

	if(potts->getDisplayUnitsFlag()){
		Unit diffConstUnit=powerUnit(potts->getLengthUnit(),2)/potts->getTimeUnit();
		Unit decayConstUnit=1/potts->getTimeUnit();
		Unit secretionConstUnit=1/potts->getTimeUnit();

		CC3DXMLElement * unitsElem=_xmlData->getFirstElement("Units"); 
		if (!unitsElem){ //add Units element
			unitsElem=_xmlData->attachElement("Units");
		}

		if(unitsElem->getFirstElement("DiffusionConstantUnit")){
			unitsElem->getFirstElement("DiffusionConstantUnit")->updateElementValue(diffConstUnit.toString());
		}else{
			unitsElem->attachElement("DiffusionConstantUnit",diffConstUnit.toString());
		}

		if(unitsElem->getFirstElement("DecayConstantUnit")){
			unitsElem->getFirstElement("DecayConstantUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("DecayConstantUnit",decayConstUnit.toString());
		}

		if(unitsElem->getFirstElement("DeltaXUnit")){
			unitsElem->getFirstElement("DeltaXUnit")->updateElementValue(potts->getLengthUnit().toString());
		}else{
			unitsElem->attachElement("DeltaXUnit",potts->getLengthUnit().toString());
		}

		if(unitsElem->getFirstElement("DeltaTUnit")){
			unitsElem->getFirstElement("DeltaTUnit")->updateElementValue(potts->getTimeUnit().toString());
		}else{
			unitsElem->attachElement("DeltaTUnit",potts->getTimeUnit().toString());
		}

		if(unitsElem->getFirstElement("CouplingCoefficientUnit")){
			unitsElem->getFirstElement("CouplingCoefficientUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("CouplingCoefficientUnit",decayConstUnit.toString());
		}



		if(unitsElem->getFirstElement("SecretionUnit")){
			unitsElem->getFirstElement("SecretionUnit")->updateElementValue(secretionConstUnit.toString());
		}else{
			unitsElem->attachElement("SecretionUnit",secretionConstUnit.toString());
		}

		if(unitsElem->getFirstElement("SecretionOnContactUnit")){
			unitsElem->getFirstElement("SecretionOnContactUnit")->updateElementValue(secretionConstUnit.toString());
		}else{
			unitsElem->attachElement("SecretionOnContactUnit",secretionConstUnit.toString());
		}

		if(unitsElem->getFirstElement("ConstantConcentrationUnit")){
			unitsElem->getFirstElement("ConstantConcentrationUnit")->updateElementValue(secretionConstUnit.toString());
		}else{
			unitsElem->attachElement("ConstantConcentrationUnit",secretionConstUnit.toString());
		}

		if(unitsElem->getFirstElement("DecayConstantUnit")){
			unitsElem->getFirstElement("DecayConstantUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("DecayConstantUnit",decayConstUnit.toString());
		}

		if(unitsElem->getFirstElement("DeltaXUnit")){
			unitsElem->getFirstElement("DeltaXUnit")->updateElementValue(potts->getLengthUnit().toString());
		}else{
			unitsElem->attachElement("DeltaXUnit",potts->getLengthUnit().toString());
		}

		if(unitsElem->getFirstElement("DeltaTUnit")){
			unitsElem->getFirstElement("DeltaTUnit")->updateElementValue(potts->getTimeUnit().toString());
		}else{
			unitsElem->attachElement("DeltaTUnit",potts->getTimeUnit().toString());
		}

		if(unitsElem->getFirstElement("CouplingCoefficientUnit")){
			unitsElem->getFirstElement("CouplingCoefficientUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("CouplingCoefficientUnit",decayConstUnit.toString());
		}

		if(unitsElem->getFirstElement("UptakeUnit")){
			unitsElem->getFirstElement("UptakeUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("UptakeUnit",decayConstUnit.toString());
		}

		if(unitsElem->getFirstElement("RelativeUptakeUnit")){
			unitsElem->getFirstElement("RelativeUptakeUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("RelativeUptakeUnit",decayConstUnit.toString());
		}

		if(unitsElem->getFirstElement("MaxUptakeUnit")){
			unitsElem->getFirstElement("MaxUptakeUnit")->updateElementValue(decayConstUnit.toString());
		}else{
			unitsElem->attachElement("MaxUptakeUnit",decayConstUnit.toString());
		}



	}


	diffSecrFieldTuppleVec.clear();
	bcSpecVec.clear();
	bcSpecFlagVec.clear();

	CC3DXMLElementList diffFieldXMLVec=_xmlData->getElements("DiffusionField");
	for(unsigned int i = 0 ; i < diffFieldXMLVec.size() ; ++i ){
		diffSecrFieldTuppleVec.push_back(DiffusionSecretionFiPyFieldTupple());
		DiffusionData & diffData=diffSecrFieldTuppleVec[diffSecrFieldTuppleVec.size()-1].diffData;
		SecretionData & secrData=diffSecrFieldTuppleVec[diffSecrFieldTuppleVec.size()-1].secrData;

		if(diffFieldXMLVec[i]->findElement("DiffusionData"))
			diffData.update(diffFieldXMLVec[i]->getFirstElement("DiffusionData"));

		if(diffFieldXMLVec[i]->findElement("SecretionData"))
			secrData.update(diffFieldXMLVec[i]->getFirstElement("SecretionData"));

		if(diffFieldXMLVec[i]->findElement("ReadFromFile"))
			readFromFileFlag=true;

		//boundary conditions parsing
		bcSpecFlagVec.push_back(false);
		bcSpecVec.push_back(BoundaryConditionSpecifier());

		if (diffFieldXMLVec[i]->findElement("BoundaryConditions")){
			bcSpecFlagVec[bcSpecFlagVec.size()-1]=true;
			BoundaryConditionSpecifier & bcSpec = bcSpecVec[bcSpecVec.size()-1];

			CC3DXMLElement * bcSpecElem = diffFieldXMLVec[i]->getFirstElement("BoundaryConditions");
			CC3DXMLElementList planeVec = bcSpecElem->getElements("Plane");



			for(unsigned int ip = 0 ; ip < planeVec.size() ; ++ip ){
				ASSERT_OR_THROW ("Boundary Condition specification Plane element is missing Axis attribute",planeVec[ip]->findAttribute("Axis"));
				string axisName=planeVec[ip]->getAttribute("Axis");
				int index=0;
				if (axisName=="x" ||axisName=="X" ){
					index=0;
				}
				if (axisName=="y" ||axisName=="Y" ){
					index=2;
				}
				if (axisName=="z" ||axisName=="Z" ){
					index=4;
				}

				if (planeVec[ip]->findElement("Periodic")){
					bcSpec.planePositions[index]=BoundaryConditionSpecifier::PERIODIC;
					bcSpec.planePositions[index+1]=BoundaryConditionSpecifier::PERIODIC;
				}else {
					//if (planeVec[ip]->findElement("ConstantValue")){
					CC3DXMLElementList cvVec=planeVec[ip]->getElements("ConstantValue");
					CC3DXMLElementList cdVec=planeVec[ip]->getElements("ConstantDerivative");

					for (unsigned int v = 0 ; v < cvVec.size() ; ++v ){
						string planePos=cvVec[v]->getAttribute("PlanePosition");
						double value=cvVec[v]->getAttributeAsDouble("Value");
						changeToLower(planePos);
						if (planePos=="min"){
							bcSpec.planePositions[index]=BoundaryConditionSpecifier::CONSTANT_VALUE;
							bcSpec.values[index]=value;

						}else if (planePos=="max"){
							bcSpec.planePositions[index+1]=BoundaryConditionSpecifier::CONSTANT_VALUE;
							bcSpec.values[index+1]=value;
						}else{
							ASSERT_OR_THROW("PlanePosition attribute has to be either max on min",false);
						}

					}
					if (cvVec.size()<=1){
						for (unsigned int d = 0 ; d < cdVec.size() ; ++d ){
							string planePos=cdVec[d]->getAttribute("PlanePosition");
							double value=cdVec[d]->getAttributeAsDouble("Value");
							changeToLower(planePos);
							if (planePos=="min"){
								bcSpec.planePositions[index]=BoundaryConditionSpecifier::CONSTANT_DERIVATIVE;
								bcSpec.values[index]=value;

							}else if (planePos=="max"){
								bcSpec.planePositions[index+1]=BoundaryConditionSpecifier::CONSTANT_DERIVATIVE;
								bcSpec.values[index+1]=value;
							}else{
								ASSERT_OR_THROW("PlanePosition attribute has to be either max on min",false);
							}

						}
					}

				}

			}

		}
	}
	if(_xmlData->findElement("Serialize")){
		serializeFlag=true;
		if(_xmlData->getFirstElement("Serialize")->findAttribute("Frequency")){
			serializeFrequency=_xmlData->getFirstElement("Serialize")->getAttributeAsUInt("Frequency");
		}
		cerr<<"serialize Flag="<<serializeFlag<<endl;
	}

	if(_xmlData->findElement("ReadFromFile")){
		readFromFileFlag=true;
		cerr<<"readFromFileFlag="<<readFromFileFlag<<endl;
	}

	for(int i = 0 ; i < diffSecrFieldTuppleVec.size() ; ++i){
		diffSecrFieldTuppleVec[i].diffData.setAutomaton(automaton);
		diffSecrFieldTuppleVec[i].secrData.setAutomaton(automaton);
		diffSecrFieldTuppleVec[i].diffData.initialize(automaton);
		diffSecrFieldTuppleVec[i].secrData.initialize(automaton);
	}

	///assigning member method ptrs to the vector
	for(unsigned int i = 0 ; i < diffSecrFieldTuppleVec.size() ; ++i){

		diffSecrFieldTuppleVec[i].secrData.secretionFcnPtrVec.assign(diffSecrFieldTuppleVec[i].secrData.secrTypesNameSet.size(),0);
		unsigned int j=0;
		for(set<string>::iterator sitr=diffSecrFieldTuppleVec[i].secrData.secrTypesNameSet.begin() ; sitr != diffSecrFieldTuppleVec[i].secrData.secrTypesNameSet.end()  ; ++sitr){

			if((*sitr)=="Secretion"){
				diffSecrFieldTuppleVec[i].secrData.secretionFcnPtrVec[j]=&FiPySolver::secreteSingleField;
				++j;
			}
			else if((*sitr)=="SecretionOnContact"){
				diffSecrFieldTuppleVec[i].secrData.secretionFcnPtrVec[j]=&FiPySolver::secreteOnContactSingleField;
				++j;
			}
			else if((*sitr)=="ConstantConcentration"){
				diffSecrFieldTuppleVec[i].secrData.secretionFcnPtrVec[j]=&FiPySolver::secreteConstantConcentrationSingleField;
				++j;
			}
		}
	}
}
void PlayerSettingsPlugin::update(CC3DXMLElement *_xmlData, bool _fullInitFlag){
	
	cerr<<"_xmlData="<<_xmlData<<endl;

	CC3DXMLElement *proj2DElement;
	proj2DElement=_xmlData->getFirstElement("Project2D");
	if(proj2DElement){

      ///reading 2D settings - projections
		if(proj2DElement->findAttribute("XYProj")){
         playerSettings.xyProj=proj2DElement->getAttributeAsUInt("XYProj");
         playerSettings.xyProjFlag=true;
		}

		if(proj2DElement->findAttribute("XZProj")){
         playerSettings.xzProj=proj2DElement->getAttributeAsUInt("XZProj");
         playerSettings.xzProjFlag=true;
		}

		if(proj2DElement->findAttribute("YZProj")){
         playerSettings.yzProj=proj2DElement->getAttributeAsUInt("YZProj");
         playerSettings.yzProjFlag=true;
		}
	}


	CC3DXMLElement *rot3DElement;
	rot3DElement=_xmlData->getFirstElement("Rotate3D");
	if(rot3DElement){

      ///reading 3D settings - rotations
		if(rot3DElement->findAttribute("XRot")){
         playerSettings.rotationX=rot3DElement->getAttributeAsUInt("XRot");
         playerSettings.rotationXFlag=true;
		}

		if(rot3DElement->findAttribute("YRot")){
         playerSettings.rotationY=rot3DElement->getAttributeAsUInt("YRot");
         playerSettings.rotationYFlag=true;
		}

		if(rot3DElement->findAttribute("ZRot")){
         playerSettings.rotationZ=rot3DElement->getAttributeAsUInt("ZRot");
         playerSettings.rotationZFlag=true;
		}

	}

	CC3DXMLElement *resize3DElement;
	resize3DElement=_xmlData->getFirstElement("Resize3D");
	if(resize3DElement){
      ///reading  3D widget size parameters used by player - the bigger the smaller object will be
      
		if(resize3DElement->findAttribute("X")){
         playerSettings.sizeX3D=resize3DElement->getAttributeAsUInt("X");
         playerSettings.sizeX3DFlag=true;
		}

		if(resize3DElement->findAttribute("Y")){
         playerSettings.sizeY3D=resize3DElement->getAttributeAsUInt("Y");
         playerSettings.sizeY3DFlag=true;
		}

		if(resize3DElement->findAttribute("Z")){
         playerSettings.sizeZ3D=resize3DElement->getAttributeAsUInt("Z");
         playerSettings.sizeZ3DFlag=true;
		}

	}
	CC3DXMLElement *view3DElement=_xmlData->getFirstElement("View3D");
	if (view3DElement){
		CC3DXMLElement *clippingRangeElement=view3DElement->getFirstElement("ClippingRange");
		if (clippingRangeElement){
			playerSettings.clippingRange[0]=clippingRangeElement->getAttributeAsDouble("Min");
			playerSettings.clippingRange[1]=clippingRangeElement->getAttributeAsDouble("Max");
		}

		CC3DXMLElement *focalPointElement=view3DElement->getFirstElement("focalPoint");
		if (focalPointElement){
			playerSettings.focalPoint[0]=focalPointElement->getAttributeAsDouble("x");
			playerSettings.focalPoint[1]=focalPointElement->getAttributeAsDouble("y");
			playerSettings.focalPoint[1]=focalPointElement->getAttributeAsDouble("z");
		}

		CC3DXMLElement *positionElement=view3DElement->getFirstElement("position");
		if (positionElement){
			playerSettings.position[0]=positionElement->getAttributeAsDouble("x");
			playerSettings.position[1]=positionElement->getAttributeAsDouble("y");
			playerSettings.position[1]=positionElement->getAttributeAsDouble("z");
		}

		CC3DXMLElement *viewUpElement=view3DElement->getFirstElement("viewUp");
		if (viewUpElement){
			playerSettings.viewUp[0]=viewUpElement->getAttributeAsDouble("x");
			playerSettings.viewUp[1]=viewUpElement->getAttributeAsDouble("y");
			playerSettings.viewUp[1]=viewUpElement->getAttributeAsDouble("z");
		}

	}

	CC3DXMLElement *initProjXMLElement=_xmlData->getFirstElement("InitialProjection");
	if(initProjXMLElement){
		if(initProjXMLElement->findAttribute("Projection")){
         playerSettings.initialProjection=initProjXMLElement->getAttribute("Projection");
         //changing to lowercase 
         changeToLower(playerSettings.initialProjection);
         ASSERT_OR_THROW("InitialProjection has have a value of xy or xz or yz",
         playerSettings.initialProjection=="xy" || playerSettings.initialProjection=="xz" || playerSettings.initialProjection=="yz"
			);
		}

	}

	CC3DXMLElement *concXMLElement;
	concXMLElement=_xmlData->getFirstElement("Concentration");
	if(concXMLElement){
      ///reading  3D widget size parameters used by player - the bigger the smaller object will be
      
		playerSettings.advancedSettingsOn=true;

		if(concXMLElement->findAttribute("Min")){
         playerSettings.minConcentration=concXMLElement->getAttributeAsDouble("Min");
         playerSettings.minConcentrationFlag=true;

         playerSettings.minConcentrationFixed=true;
         playerSettings.minConcentrationFixedFlag=true;

		}

		if(concXMLElement->findAttribute("Max")){
         playerSettings.maxConcentration=concXMLElement->getAttributeAsDouble("Max");
         playerSettings.maxConcentrationFlag=true;
         playerSettings.maxConcentrationFixed=true;
         playerSettings.maxConcentrationFixedFlag=true;

		}


		if(concXMLElement->findAttribute("MinFixed")){
         playerSettings.minConcentrationFixed=concXMLElement->getAttributeAsBool("MinFixed");
         playerSettings.minConcentrationFixedFlag=true;
		}

		if(concXMLElement->findAttribute("MaxFixed")){
         playerSettings.maxConcentrationFixed=concXMLElement->getAttributeAsBool("MaxFixed");
         playerSettings.maxConcentrationFixedFlag=true;
		}

		if(concXMLElement->findAttribute("LegendEnable")){
         playerSettings.legendEnable=concXMLElement->getAttributeAsBool("LegendEnable");
         playerSettings.legendEnableFlag=true;
		}

		if(concXMLElement->findAttribute("NumberOfLegendBoxes")){
         playerSettings.numberOfLegendBoxes=concXMLElement->getAttributeAsUInt("NumberOfLegendBoxes");
         playerSettings.numberOfLegendBoxesFlag=true;
		}

		if(concXMLElement->findAttribute("NumberAccuracy")){
         playerSettings.numberAccuracy=concXMLElement->getAttributeAsUInt("NumberAccuracy");
         playerSettings.numberAccuracyFlag=true;
		}

		if(concXMLElement->findAttribute("ConcentrationLimitsOn")){
         playerSettings.concentrationLimitsOn=concXMLElement->getAttributeAsBool("ConcentrationLimitsOn");
         playerSettings.concentrationLimitsOnFlag=true;
		}


	}


	CC3DXMLElement *magnitudeXMLElement;
	magnitudeXMLElement=_xmlData->getFirstElement("Magnitude");
	if(magnitudeXMLElement){
      ///reading  3D widget size parameters used by player - the bigger the smaller object will be
      
		playerSettings.advancedSettingsOn=true;

		if(magnitudeXMLElement->findAttribute("Min")){
         playerSettings.minMagnitude=magnitudeXMLElement->getAttributeAsDouble("Min");
         playerSettings.minMagnitudeFlag=true;

         playerSettings.minMagnitudeFixed=true;
         playerSettings.minMagnitudeFixedFlag=true;			
		}

		if(magnitudeXMLElement->findAttribute("Max")){
         playerSettings.maxMagnitude=magnitudeXMLElement->getAttributeAsDouble("Max");
         playerSettings.maxMagnitudeFlag=true;

         playerSettings.maxMagnitudeFixed=true;
         playerSettings.maxMagnitudeFixedFlag=true;			
		}


		if(magnitudeXMLElement->findAttribute("MinFixed")){
         playerSettings.minMagnitudeFixed=magnitudeXMLElement->getAttributeAsBool("MinFixed");
         playerSettings.minMagnitudeFixedFlag=true;
		}

		if(magnitudeXMLElement->findAttribute("MaxFixed")){
         playerSettings.maxMagnitudeFixed=magnitudeXMLElement->getAttributeAsBool("MaxFixed");
         playerSettings.maxMagnitudeFixedFlag=true;
		}




		if(magnitudeXMLElement->findAttribute("LegendEnable")){
         playerSettings.legendEnableVector=magnitudeXMLElement->getAttributeAsBool("LegendEnable");
         playerSettings.legendEnableVectorFlag=true;			
		}


		if(magnitudeXMLElement->findAttribute("NumberOfLegendBoxes")){
			playerSettings.numberOfLegendBoxesVector=magnitudeXMLElement->getAttributeAsUInt("NumberOfLegendBoxes");
         playerSettings.numberOfLegendBoxesVectorFlag=true;
		}

		if(magnitudeXMLElement->findAttribute("NumberAccuracy")){
         playerSettings.numberAccuracyVector=magnitudeXMLElement->getAttributeAsUInt("NumberAccuracy");
         playerSettings.numberAccuracyVectorFlag=true;
		}

		if(magnitudeXMLElement->findAttribute("OverlayVectorAndCellFields")){
         playerSettings.overlayVectorCellFields=magnitudeXMLElement->getAttributeAsBool("OverlayVectorAndCellFields");
         playerSettings.overlayVectorCellFieldsFlag=true;
		}

		if(magnitudeXMLElement->findAttribute("ScaleArrows")){
         playerSettings.scaleArrows=magnitudeXMLElement->getAttributeAsBool("ScaleArrows");
         playerSettings.scaleArrowsFlag=true;
		}

		if(magnitudeXMLElement->findAttribute("FixedArrowColorFlag")){
         playerSettings.fixedArrowColorFlag=magnitudeXMLElement->getAttributeAsBool("FixedArrowColorFlag");
         playerSettings.fixedArrowColorFlagFlag=true;
		}

		if(magnitudeXMLElement->findAttribute("ArrowColor")){
         playerSettings.arrowColorName=magnitudeXMLElement->getAttribute("ArrowColor");
         changeToLower(playerSettings.arrowColorName);
         playerSettings.arrowColorNameFlag=true;
		}

	}

	CC3DXMLElement *borderXMLElement=_xmlData->getFirstElement("Border");
	if(borderXMLElement){
		
		playerSettings.advancedSettingsOn=true;      

		if(borderXMLElement->findAttribute("Color")){
         playerSettings.borderColorName=borderXMLElement->getAttribute("Color");
         //changing to lowercase 
         changeToLower(playerSettings.borderColorName);
         playerSettings.borderColorNameFlag=true;
		}
		if(borderXMLElement->findAttribute("BorderOn")){
         playerSettings.borderOn=borderXMLElement->getAttributeAsBool("BorderOn");
         playerSettings.borderOnFlag=true;
		}
	}

	CC3DXMLElement *contourXMLElement=_xmlData->getFirstElement("Contour");
	if(contourXMLElement){
		
		playerSettings.advancedSettingsOn=true;      

		if(contourXMLElement->findAttribute("Color")){

         playerSettings.contourColorName=contourXMLElement->getAttribute("Color");
         
         //changing to lowercase 
         changeToLower(playerSettings.contourColorName);
         playerSettings.contourColorNameFlag=true;
		}

		if(contourXMLElement->findAttribute("ContourOn")){
         playerSettings.contourOn=contourXMLElement->getAttributeAsBool("ContourOn");
         playerSettings.contourOnFlag=true;
		}
	}

	CC3DXMLElementList cellColorVecXML=_xmlData->getElements("Cell");
	for(int i = 0 ; i < cellColorVecXML.size() ; ++i ){
		playerSettings.advancedSettingsOn=true;

      std::string color;
      unsigned short type;

      type=(unsigned short)cellColorVecXML[i]->getAttributeAsUInt("Type");
      color=cellColorVecXML[i]->getAttributeAsUInt("Color");

      playerSettings.typeToColorNameMap[type]=color;
      playerSettings.typeToColorNameMapFlag=true;

	}

	CC3DXMLElement *visContrXMLElement=_xmlData->getFirstElement("VisualControl");
	if(visContrXMLElement){
      
		playerSettings.advancedSettingsOn=true;
		
		if(visContrXMLElement->findAttribute("ZoomFactor")){
         playerSettings.zoomFactor=visContrXMLElement->getAttributeAsUInt("ZoomFactor");
         playerSettings.zoomFactorFlag=true;
		}

		if(visContrXMLElement->findAttribute("ScreenshotFrequency")){
         playerSettings.screenshotFrequency=visContrXMLElement->getAttributeAsUInt("ScreenshotFrequency");
         playerSettings.screenshotFrequencyFlag=true;
		}

		if(visContrXMLElement->findAttribute("ScreenUpdateFrequency")){
         playerSettings.screenUpdateFrequency=visContrXMLElement->getAttributeAsUInt("ScreenUpdateFrequency");
         playerSettings.screenUpdateFrequencyFlag=true;
		}

		if(visContrXMLElement->findAttribute("NoOutput")){
         playerSettings.noOutputFlag=visContrXMLElement->getAttributeAsBool("NoOutput");
         playerSettings.noOutputFlagFlag=true;
		}
	}


	CC3DXMLElement *types3DInvisElement=_xmlData->getFirstElement("TypesInvisibleIn3D");
	if(types3DInvisElement){
		
      playerSettings.advancedSettingsOn=true;

      std::string typesInvisibleIn3DString=types3DInvisElement->getAttribute("Types");
      vector<string> typesInvisiblein3DVector; 
      parseStringIntoList(typesInvisibleIn3DString,typesInvisiblein3DVector,",");

      for(unsigned int i = 0 ; i < typesInvisiblein3DVector.size() ; ++i){
         playerSettings.types3DInvisible.push_back((unsigned short)BasicString::parseUInteger(typesInvisiblein3DVector[i]));
      }

      playerSettings.types3DInvisibleFlag=true;

	}

	CC3DXMLElement *settingsXMLElement=_xmlData->getFirstElement("Settings");
	if(settingsXMLElement){
		if(settingsXMLElement->findAttribute("SaveSettings")){
         playerSettings.saveSettings=settingsXMLElement->getAttributeAsBool("SaveSettings");
         playerSettings.saveSettingsFlag=true;

		}
	}

}